Java Exception Handling - Interview-Friendly Guide

1. What is an Exception?

An exception is an event that disrupts the normal flow of a program at runtime. Think of it as a "warning light" that signals something went wrong, allowing the program to handle it gracefully instead of crashing.

Code Example:

int a = 10;
int b = 0;
int result = a / b;  // Throws ArithmeticException: divide by zero

2. Throwable Class & Exception Hierarchy

The Throwable class is the root of Java’s exception hierarchy. All exceptions and errors inherit from it, like the "trunk" of a family tree.

Two Main Subclasses:

• Exception: Recoverable issues (e.g., file not found) – handle these!
• Error: Severe, unrecoverable problems (e.g., out of memory) – avoid catching!

Exception Hierarchy Diagram:

Fallback Text Diagram (if image fails):

Throwable
├── Exception
│   ├── Checked Exceptions (e.g., IOException, SQLException)
│   └── RuntimeException (Unchecked, e.g., NullPointerException)
└── Error (e.g., OutOfMemoryError, StackOverflowError)
                

Checked Exceptions (Compile-Time)

• Checked at compile time.
• Must be handled with try-catch or declared with throws.
• Examples: IOException, SQLException, FileNotFoundException.

Unchecked Exceptions (Runtime)

• Occur at runtime, not checked by compiler.
• Optional to handle, but good practice to anticipate.
• Examples: NullPointerException, ArithmeticException, ArrayIndexOutOfBoundsException.

Error Class (Unrecoverable)

• StackOverflowError: Infinite recursion.
• OutOfMemoryError: No heap space.
• VirtualMachineError: JVM issues.

3. try-catch-finally

The backbone of exception handling: try for risky code, catch for handling errors, finally for cleanup.

Flow Diagram:

Fallback Text Diagram (if image fails):

[Start] → [Try: Risky Code]
           ├── Exception → [Catch: Handle It]
           └── [Finally: Cleanup]
[End]
                

Syntax:

try {
    // Risky code
} catch (ExceptionType e) {
    // Handle exception
} finally {
    // Cleanup (always runs)
}

try {
    int result = 10 / 0; // Throws ArithmeticException
} catch (ArithmeticException e) {
    System.out.println("Cannot divide by zero!");
} finally {
    System.out.println("Cleanup done!");
}

4. throw vs throws

Key for controlling exceptions manually or warning about them.

Comparison Diagram:

Fallback Text Diagram (if image fails):

throw: Actively throws an exception object
throws: Declares possible exceptions in method signature
                

Easy Explanation:

• throw: "I’m throwing this error now!" (Action).
• throws: "Heads up, this method might throw errors!" (Warning).

void validateAge(int age) {
    if (age < 18) {
        throw new IllegalArgumentException("Underage!");
    }
}

void readFile() throws IOException {
    FileReader fr = new FileReader("file.txt");
}

5. Custom Exception

Create tailored exceptions for specific scenarios, extending Exception (checked) or RuntimeException (unchecked).

class InvalidAgeException extends Exception {
    InvalidAgeException(String msg) {
        super(msg);
    }
}

void checkAge(int age) throws InvalidAgeException {
    if (age < 18) {
        throw new InvalidAgeException("Age too low!");
    }
}

6. final vs finally vs finalize()

These sound similar but are distinct – a favorite interview topic!

Comparison Diagram:

8. Interview Summary Table

Real Interview Questions & Answers

Commonly asked in companies like Google, Amazon, Microsoft, etc.